Turtle

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВ

Разработчику Архитектору

Turtle

Черепашья графика

Графический интерфейс в языке программирования Python может быть реализован различными способами — от простой черепашьей графики до полноценных 2D-приложений и сложных GUI-систем. Сначала поговорим о простой графике.

В жизни каждого специалиста возникают ситуации-конфузы. Так вот, после многих лет разработки на языках C#, Java, JavaScript, Python я встречаю некую «черепашью графику» в Python, причём в курсе программирования для детей. У меня конфуз - что за черепашья графика? Почему графика? Что имеется в виду? GUI? 2D/3D? Вектор/растр?

Потом ещё веселее - объекты в «черепашьей графике». Объектно-ориентированное программирование? Да? Или нет?

Оказалось, что есть такое необычное изобретение в истории обучения программированию. Профессионалы учатся немного иначе, тогда как новичков и детей учат совсем простым вещам, о которых мы даже не задумываемся.

Так вот, черепашья графика (Turtle Graphics) - это визуальный способ программирования, при котором мы управляем виртуальной черепашкой, которая ползёт по экрану и рисует линии. Она как художник с карандашом: куда она ползёт — там остаётся след. Это простая 2D-графика, где учатся программировать через наглядные действия вроде «иди вперёд», «поверни налево», «подними карандаш» и т.д.

Название происходит от языка Logo, который был разработан в 1960-х годах для обучения детей программированию. В нём была физическая игрушечная черепаха на полу, которая двигалась по командам и рисовала мелом. Потом эта идея перешла в виртуальную черепашку на экране.

В Python модуль turtle — это современная реализация этой идеи. Он встроен в стандартную библиотеку, то есть не нужно ничего устанавливать — просто пишем:

import turtle

И начинаем рисовать.

Базовая структура скрипта включает импорт, создание объектов, выполнение команд и завершение работы.

import turtle

# Создание экрана
screen = turtle.Screen()

# Создание черепахи
pen = turtle.Turtle()

# Команды рисования
pen.forward(100)

# Завершение работы
turtle.done()

Модуль turtle входит в стандартную библиотеку Python и предоставляет простую, но мощную систему для работы с двумерной графикой. Основная идея заключается в концепции «черепахи» — абстрактного исполнителя, перемещающегося по координатной плоскости и оставляющего за собой след. Через последовательность команд можно управлять направлением движения, положением, цветом линии и другими параметрами.

Задумка следующая - на экране появляется маленькая стрелочка (или черепашка, если включить соответствующую форму). У неё есть:

• Позиция (x, y) — где она находится.
• Направление — куда смотрит (например, вверх, вправо).
• Ручка (pen) — опущена (рисует) или поднята (не рисует).
• Цвет линии, цвет заливки, толщина линии, скорость движения.

Задача как раз в управлении «черепашкой» при помощи команд.

Чтобы окно не закрывалось сразу, нужно добавлять в конец кода:

turtle.done()

Функция turtle.done() запускает главный цикл обработки событий. Окно остаётся открытым до момента закрытия пользователем. Отсутствие этого вызова приводит к мгновенному закрытию окна после выполнения скрипта.

Команды там следующие:

• forward(100) - Черепашка идёт вперёд на 100 пикселей;
• backward(50) - Назад на 50 пикселей;
• left(90) - Поворачивает налево на 90 градусов;
• right(45) - Направо на 45°;
• penup() - Поднимает ручку — больше не рисует;
• pendown() - Опускает ручку — снова рисует;
• goto(x, y) - Мгновенно перемещается в точку (x, y);
• color("red") - Устанавливает цвет ручки и заливки;
• pencolor("blue") - Только цвет линии;
• fillcolor("yellow") - Цвет заливки фигур;
• begin_fill() / end_fill() - Начинает и заканчивает заливку области;
• speed(5) - Скорость от 1 (медленно) до 10 (быстро), 0 — мгновенно;
• shape("turtle") - Меняет внешний вид: "arrow", "circle", "turtle" и др.

Пример: рисование квадрата.

Это как цикл for в C#, только вместо изменения переменной мы меняем состояние объекта.

Хотя это не GUI с кнопками, это графика в математическом смысле: работа с координатной плоскостью, углами, фигурами, цветами, траекториями. Экран является координатной плоскостью, где центр (0,0) - середина экрана, X вправо, Y вверх, как в базовой математике.

Так рисуют геометрические фигуры, используя циклы и функции, можно даже фракталы, узоры, анимации.

Здесь каждая черепашка — объект класса Turtle.

t1 = turtle.Turtle()
t2 = turtle.Turtle()

t1.color("red")
t2.color("blue")

t1.goto(-100, 0)
t2.goto(100, 0)

Технически, модуль turtle содержит в себе класс Turtle и при помощи конструктора Turtle() создаётся черепашка как объект, имеющий свойства и поведение. Концепция как раз в том, чтобы использовать методы черепашки для управления и рисования фигур.

t1 и t2 образуют две независимые «кисти», которые могут двигаться параллельно, рисовать разными цветами, иметь разную скорость и выполнять разные программы. Это отличный способ показать детям (и напомнить взрослым), что объекты — это экземпляры класса с собственным состоянием и поведением.

Чтобы не писать 360 строк для круга, можно использовать цикл, и получить почти круг (технически это 360-угольник). Можно делать розетки, спирали, снежинки Коха — всё через повторение простых действий.

for _ in range(360):
    t.forward(1)
    t.left(1)

Пример - две черепахи навстречу.

t1 = turtle.Turtle()
t2 = turtle.Turtle()

t1.penup()
t1.goto(-200, 0)
t1.pendown()
t1.color("red")

t2.penup()
t2.goto(200, 0)
t2.pendown()
t2.color("blue")
t2.setheading(180)  # смотрит влево

# Ползут навстречу
for _ in range(100):
    t1.forward(2)
    t2.forward(2)

Так можно наглядно увидеть, что каждый объект живёт своей жизнью.

В объектно-ориентированной парадигме turtle представляет собой класс Turtle, экземпляры которого обладают состоянием (позиция, угол поворота, цвет пера, видимость) и поведением (методы перемещения, рисования, изменения стиля). Каждая черепаха работает в рамках общего холста — экземпляра класса Screen, который управляет окном вывода, фоном и событиями.

Черепаха может быть склонирована, переопределена или инкапсулирована в пользовательские классы, что позволяет строить более сложные графические системы.

Система координат в turtle — прямоугольная, с началом в центре окна. Положительное направление оси X — вправо, оси Y — вверх. Размеры окна задаются явно через метод setup(width, height) класса Screen. Координаты могут быть абсолютными (например, goto(x, y)) или относительными (например, forward(distance)).

Ориентация угла измеряется в градусах против часовой стрелки от положительного направления оси X. Поворот осуществляется командами left(angle) и right(angle).

Модуль поддерживает широкий спектр способов задания цветов:

• Строковые имена: "red", "blue", "green" и др.
• RGB-значения в формате кортежа (r, g, b), где каждое значение — число от 0 до 1 (или от 0 до 255 при активации режима colormode(255)).
• HEX-коды: "#FF5733".

Для заливки фигур используется комбинация методов begin_fill() и end_fill(), которые фиксируют контур и применяют текущий цвет заполнения.

Например, можно нарисовать сердечко:

import turtle
import math

t = turtle.Turtle()
t.speed(0)
screen = turtle.Screen()
screen.bgcolor("white")

t.begin_fill()
t.fillcolor("red")

t.left(50)
t.forward(133)
t.circle(50, 200)
t.right(140)
t.circle(50, 200)
t.forward(133)

t.end_fill()

t.penup()

t.hideturtle()
turtle.done()

Анимация в turtle реализуется через последовательное изменение состояния черепахи с контролем скорости выполнения. Метод speed(n) позволяет установить скорость от 0 (мгновенно) до 10 (медленно). Для плавной анимации используются циклы с задержками, хотя сам модуль не является реалтайм-движком.

Обработка событий (например, нажатия клавиш, кликов мыши) осуществляется через регистрацию обработчиков:

def move_forward():
    t.forward(10)

screen.onkey(move_forward, "Up")
screen.listen()

Здесь важно понимать, что turtle использует внутренний event loop, запускаемый вызовом screen.mainloop() — без него события не будут обрабатываться.

Поэтому всегда нужно добавлять в код следующее:

screen.listen()  # ← ВАЖНО! Без этого не будет работать

К примеру, так можно реализовать управление:

import turtle

screen = turtle.Screen()
screen.listen()

t = turtle.Turtle()
t.shape("turtle")
t.color("green")

def go_up():
    t.setheading(90)
    t.forward(20)

def go_down():
    t.setheading(270)
    t.forward(20)

def go_left():
    t.setheading(180)
    t.forward(20)

def go_right():
    t.setheading(0)
    t.forward(20)

screen.onkey(go_up, "Up")
screen.onkey(go_down, "Down")
screen.onkey(go_left, "Left")
screen.onkey(go_right, "Right")
screen.onkey(screen.bye, "q")

print("Управление: стрелки — движение, Q — выход")

turtle — однопоточная система; длительные операции блокируют интерфейс, и этот модуль не предназначен для производительных графических задач. Использует Tkinter в качестве бэкенда, что делает его зависимым от наличия GUI-среды. Подходит для обучения, прототипирования и демонстрации алгоритмов, но не для промышленных приложений.

---

Класс Screen

Объект Screen управляет окном приложения. Через него задаются размеры, цвет фона, заголовок и обработчики событий.

Метод	Параметры	Описание
turtle.Screen()	—	Создаёт объект главного окна
setup(width, height)	числа	Устанавливает размеры окна в пикселях
title(string)	строка	Задаёт заголовок окна
bgcolor(color)	цвет	Устанавливает цвет фона
bgpic(picname)	путь к файлу	Устанавливает изображение фона
mode(mode)	"standard", "logo", "parent"	Выбирает режим координат и углов
tracer(n)	число	Управляет анимацией отрисовки (0 выключает)
update()	—	Обновляет экран при выключенном трассировщике
exitonclick()	—	Закрывает окно по клику
bye()	—	Закрывает окно программно

Экран регистрирует нажатия клавиш и клики мыши. Обработчики событий представляют собой функции, вызываемые при наступлении события.

def move():
    pen.forward(50)

screen.onkey(move, "space")
screen.listen()

Вызов screen.listen() активирует прослушивание событий клавиатуры. Без этого вызова обработчики не срабатывают.

---

Класс Turtle

Объект Turtle представляет собой исполнителя. Каждый экземпляр класса обладает собственным состоянием: координатами, углом поворота, цветом пера, видимостью.

Движение и положение:

Метод	Параметры	Описание
forward(distance)	число	Движение вперёд на указанное расстояние
backward(distance)	число	Движение назад
right(angle)	число	Поворот направо на угол в градусах
left(angle)	число	Поворот налево на угол в градусах
goto(x, y)	числа	Перемещение в точку с координатами (x, y)
setx(x)	число	Установка координаты X
sety(y)	число	Установка координаты Y
setheading(angle)	число	Установка абсолютного угла направления
home()	—	Возврат в центр (0, 0) и направление вверх
circle(radius)	число	Рисование круга заданного радиуса
dot(size, color)	число, цвет	Рисование точки
stamp()	—	Оставляет отпечаток черепахи на холсте
clearstamp(id)	число	Удаляет отпечаток по идентификатору
position()	—	Возвращает текущие координаты (x, y)
heading()	—	Возвращает текущий угол поворота
distance(obj)	объект	Возвращает расстояние до другого объекта

Управление пером:

Метод	Параметры	Описание
pendown()	—	Опускает перо (рисует при движении)
penup()	—	Поднимает перо (не рисует при движении)
pensize(width)	число	Устанавливает толщину линии
pencolor(color)	цвет	Устанавливает цвет линии
fillcolor(color)	цвет	Устанавливает цвет заливки
color(color)	цвет	Устанавливает цвет пера и заливки
begin_fill()	—	Начинает запись контура для заливки
end_fill()	—	Завершает заливку замкнутого контура
filling()	—	Возвращает статус заливки (True/False)
reset()	—	Сбрасывает состояние черепахи и очищает экран
clear()	—	Очищает рисунки, сохраняет положение
undo()	—	Отменяет последнее действие
speed(value)	0-10	Устанавливает скорость (0 — мгновенно)
hideturtle()	—	Скрывает курсор черепахи
showturtle()	—	Показывает курсор черепахи
isvisible()	—	Возвращает видимость курсора

---

Координатная система

По умолчанию используется декартова система координат. Начало отсчёта (0, 0) находится в центре окна. Ось X направлена вправо, ось Y направлена вверх. Углы измеряются в градусах. Нулевой угол направлен вправо (восток), отсчёт идёт против часовой стрелки.

Режим standard устанавливает направление 0 градусов вправо. Режим logo устанавливает направление 0 градусов вверх.

Координаты принимают целые и дробные значения. Метод goto() перемещает объект в указанную точку. Методы setx() и sety() меняют одну из координат.

---

Обработка ввода и событий

Система событий реагирует на действия пользователя. Регистрация обработчиков происходит через объект Screen.

Метод onkey(fun, key) связывает функцию с клавишей. Срабатывание происходит при отпускании клавиши. Метод onkeypress(fun, key) срабатывает при нажатии и удержании (требует вызова listen()).

Регистр символов имеет значение. Клавиша "A" и клавиша "a" представляют собой разные события. Для букв нижнего регистра используется строчное обозначение. Для специальных клавиш используются строковые константы.

Клавиша	Обозначение в коде
Пробел	"space"
Вверх	"Up"
Вниз	"Down"
Влево	"Left"
Вправо	"Right"
Enter	"Return"
Esc	"Escape"
Tab	"Tab"
Backspace	"BackSpace"
Delete	"Delete"
Home	"Home"
End	"End"
Page Up	"Page_Up"
Page Down	"Page_Down"
F1 - F12	"F1" ... "F12"
Буквы	"a" ... "z", "A" ... "Z"
Цифры	"0" ... "9"
Плюс	"plus"
Минус	"minus"
Точка	"period"

Пример регистрации клавиш:

def move_up():
    pen.setheading(90)
    pen.forward(20)

screen.onkey(move_up, "Up")
screen.onkey(move_up, "w")
screen.listen()

Обработка мыши позволяет реагировать на клики в любом месте экрана или на объектах.

Метод	Описание
onclick(fun)	Вызывает функцию при клике на черепаху
onrelease(fun)	Вызывает функцию при отпускании кнопки на черепахе
ondrag(fun)	Вызывает функцию при перетаскивании черепахи
onscreenclick(fun)	Вызывает функцию при клике по экрану

Функция обработчика клика получает координаты события x и y.

def go_to(x, y):
    pen.goto(x, y)

screen.onscreenclick(go_to)

---

Графика и внешний вид

Система поддерживает несколько форматов задания цвета.

1. Строковые имена: "red", "green", "blue", "yellow", "black", "white", "purple", "orange" и другие стандартные названия.
2. RGB кортеж: (r, g, b). Значения находятся в диапазоне от 0 до 1 по умолчанию.
3. RGB 255: Требуется вызов screen.colormode(255). Значения находятся в диапазоне от 0 до 255.
4. HEX: Строки вида "#FF5733".

Пример настройки цвета:

screen.colormode(255)
pen.pencolor((255, 0, 0))  # Красный
pen.fillcolor("#00FF00")   # Зелёный

Курсор черепахи имеет форму. Доступны встроенные формы и пользовательские изображения.

Форма	Обозначение
Стрелка	"arrow"
Черепаха	"turtle"
Круг	"circle"
Квадрат	"square"
Треугольник	"triangle"
Классическая	"classic"

Метод shape(name) меняет внешний вид курсора.

Использование собственных изображений требует регистрации формы в объекте экрана. Файл изображения должен находиться в рабочей директории или путь должен быть указан полностью. Поддерживаются форматы GIF, PNG (зависит от версии Tkinter).

screen.register_shape("ship.gif")
pen.shape("ship.gif")

Изображение становится доступным для всех черепах после регистрации. Центр изображения совпадает с координатами черепахи.

Модуль позволяет выводить текст на холст через метод write().

Параметр	Описание
arg	Текст для вывода
move	Boolean. Перемещает ли черепаху после вывода
align	Выравнивание: "left", "center", "right"
font	Кортеж (шрифт, размер, стиль)

Пример вывода текста:

pen.write("Старт", align="center", font=("Arial", 16, "bold"))

Стили шрифта: "normal", "bold", "italic", "bold italic".

---

Логика и циклы

Использование циклов позволяет создавать повторяющиеся узоры и фигуры. Конструкция for i in range() задаёт количество повторений.

Сумма внешних углов любого замкнутого многоугольника равна 360 градусам. Угол поворота для правильного многоугольника вычисляется как 360, делённое на количество сторон.

sides = 6
angle = 360 / sides

for i in range(sides):
    pen.forward(100)
    pen.right(angle)

Изменение расстояния или угла внутри цикла создаёт спираль.

for i in range(100):
    pen.forward(i * 2)
    pen.right(90)

Модуль random генерирует случайные числа для вариативности рисунка.

import random

colors = ["red", "blue", "green", "yellow"]

for i in range(50):
    pen.pencolor(random.choice(colors))
    pen.forward(random.randint(50, 100))
    pen.right(random.randint(0, 360))

Скрипт реализует движение объекта стрелками клавиатуры.

import turtle

screen = turtle.Screen()
screen.setup(500, 500)
screen.title("Управление")

player = turtle.Turtle()
player.shape("turtle")
player.penup()
player.speed(0)

def move_up():
    player.setheading(90)
    player.forward(20)

def move_down():
    player.setheading(270)
    player.forward(20)

def move_left():
    player.setheading(180)
    player.forward(20)

def move_right():
    player.setheading(0)
    player.forward(20)

screen.onkey(move_up, "Up")
screen.onkey(move_down, "Down")
screen.onkey(move_left, "Left")
screen.onkey(move_right, "Right")
screen.listen()

turtle.done()

Пример создания закрашенного круга.

import turtle

screen = turtle.Screen()
pen = turtle.Turtle()

pen.fillcolor("blue")
pen.begin_fill()
pen.circle(50)
pen.end_fill()

turtle.done()

Программа рисует линии вслед за курсором мыши при нажатой кнопке.

import turtle

screen = turtle.Screen()
pen = turtle.Turtle()
pen.speed(0)

def drag(x, y):
    pen.ondrag(None)  # Блокировка рекурсии
    pen.goto(x, y)
    pen.ondrag(drag)  # Возврат обработчика

pen.ondrag(drag)
screen.listen()
turtle.done()

Метод ontimer(fun, delay) запускает функцию через указанный интервал времени в миллисекундах. Это создаёт эффект анимации без блокировки цикла.

import turtle

screen = turtle.Screen()
pen = turtle.Turtle()
angle = 0

def rotate():
    global angle
    pen.clear()
    pen.setheading(angle)
    pen.forward(50)
    pen.stamp()
    angle += 10
    screen.ontimer(rotate, 100)  # Запуск через 100 мс

pen.speed(0)
rotate()
turtle.done()

Проверка расстояния между объектами позволяет реализовать простую коллизию.

import turtle
import random

screen = turtle.Screen()
player = turtle.Turtle()
target = turtle.Turtle()

player.shape("turtle")
player.penup()
target.shape("circle")
target.color("red")
target.penup()
target.goto(random.randint(-200, 200), random.randint(-200, 200))

def move():
    player.forward(20)
    if player.distance(target) < 20:
        target.goto(random.randint(-200, 200), random.randint(-200, 200))

screen.onkey(move, "space")
screen.listen()
turtle.done()

Отрисовка каждого кадра анимации может замедлять работу программы. Метод tracer(0) отключает автоматическое обновление экрана. Обновление происходит только при вызове screen.update().

screen.tracer(0)

for i in range(100):
    pen.forward(1)
    # Экран не обновляется здесь

screen.update()  # Обновление один раз в конце

Этот подход устраняет мерцание и повышает производительность при большом количестве объектов.

---

Работа с несколькими черепахами

Создание нескольких экземпляров класса Turtle позволяет управлять независимыми объектами.

t1 = turtle.Turtle()
t2 = turtle.Turtle()

t1.color("red")
t2.color("blue")

t1.goto(-50, 0)
t2.goto(50, 0)

t1.circle(30)
t2.circle(30)

Каждая черепаха хранит своё состояние независимо. Команды, отправленные одному объекту, не влияют на другие.

---

Сохранение и экспорт

Модуль turtle не имеет встроенной функции сохранения холста в файл изображения напрямую через стандартный API. Для сохранения результата используется скриншот операционной системы или сторонние библиотеки захвата экрана. Состояние программы (позиции, переменные) сохраняется через стандартные средства Python (модуль pickle или запись в файл).

---

Ограничения среды

Библиотека зависит от Tkinter. Запуск скрипта требует наличия графической среды. На серверах без графического интерфейса (headless) выполнение кода вызовет ошибку. Производительность ограничена возможностями интерпретатора Python и скоростью отрисовки Tkinter. Обработка большого количества объектов (более 100-200 активных спрайтов) приводит к снижению частоты кадров. Для сложных игр рекомендуется использовать специализированные движки.

---